﻿#define  _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<list>
using namespace std;

//class Student
//{
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 
//	void identity()
//	{
//		// ...
//	}
//	// 学习 
//	void study()
//	{
//		// ...
//	}
//protected:
//	string _name = "peter"; // 姓名 
//	string _address; // 地址 
//	string _tel; // 电话 
//	int _age = 18; // 年龄 
//	int _stuid; // 学号 
//};
//class Teacher
//{
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 
//	void identity()
//	{
//		// ...
//	}
//	// 授课 
//	void teaching()
//	{
//		//...
//	}
//protected:
//	string _name = "张三"; // 姓名 
//	int _age = 18; // 年龄 
//	string _address; // 地址 
//	string _tel; // 电话 
//	string _title; // 职称 
//};
//int main()
//{
//	return 0;
//}

//class Person
//{
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 
//	void identity()
//	{
//		cout << "void identity()" << _name << endl;
//	}
//
//	void func()
//	{
//		cout << _age << endl;
//	}
//protected:
//	string _name = "张三"; // 姓名 
//	string _address; // 地址 
//	string _tel; // 电话 
//private:
//	int _age = 18; // 年龄 
//};
//
//class Student : public Person
//{
//public:
//	// 学习 
//	void study()
//	{
//		// ...
//		//基类私有成员，派生类中不可见，语法上限制不能直接使用
//		//cout << _age << endl;
//
//		//但可以间接使用
//		func();
//	}
//protected:
//	int _stuid; // 学号 
//};
//
//class Teacher : public Person
//{
//public:
//	// 授课 
//	void teaching()
//	{
//		//...
//	}
//protected:
//	string title; // 职称 
//};
//
//int main()
//{
//	Student s;
//	Teacher t;
//	
//	s.identity();
//	t.identity();
//
//	return 0;
//}

//namespace xxx
//{
//	//template<class T>
//	//class vector
//	//{};
//
//	template<class T>
//	class stack : public vector<T>
//	{
//	public:
//		void push(const T& x)
//		{
//			// 基类是类模板时，需要指定⼀下类域， 
//			// 否则编译报错:error C3861: “push_back”: 找不到标识符 
//			// 因为stack<int>实例化时，也实例化vector<int>了 
//			// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到 
//			vector<T>::push_back(x);
//			//push_back(x);
//		}
//		void pop()
//		{
//			vector<T>::pop_back();
//		}
//		const T& top()
//		{
//			return vector<T>::back();
//		}
//		bool empty()
//		{
//			return vector<T>::empty();
//		}
//	};
//}
//
//int main()
//{
//	xxx::stack<int> st;
//	st.push(1);
//	st.push(2);
//	st.push(3);
//
//	while (!st.empty())
//	{
//		cout << st.top() << " ";
//		st.pop();
//	}
//	return 0;
//}

//class Person
//{
//protected:
//	string _name; // 姓名 
//	string _sex; // 性别 
//	int _age; // 年龄 
//};
//class Student : public Person
//{
//public:
//	int _No; // 学号 
//};
//
//int main()
//{
//	int i = 1;
//	double d = i;
//	const double& rd = i;
//
//	string s1 = "sssss";
//	const string& s1 = "sssss";
//
//	Student s;
//	Person p = s;
//	Person& rp = s;
//
//	return 0;
//}

//class Person
//{
//protected:
//	string _name = "⼩李⼦"; // 姓名 
//	int _num = 111; // ⾝份证号 
//};
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		cout << _num << endl;
//		cout << Person::_num << endl;
//	}
//protected:
//	int _num = 999; // 学号 
//};
//
//int main()
//{
//	Student s;
//	s.Print();
//
//	return 0;
//};
//
//class A
//{
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		cout << "func(int i)" << i << endl;
//	}
//};
//int main()
//{
//	B b;
//	b.fun(10);
//	b.fun();
//	return 0;
//};

//class Person
//{
//public:
//	Person(const char* name = "peter")//基类默认构造
//		: _name(name)
//	{
//		cout << "Person()" << endl;
//	}
//
//	Person(const Person& p)
//		: _name(p._name)
//	{
//		cout << "Person(const Person& p)" << endl;
//	}
//
//	Person& operator=(const Person& p)
//	{
//		cout << "Person operator=(const Person& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//
//		return *this;
//	}
//
//	~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//protected:
//	string _name; // 姓名 
//};
//
//class Student : public Person
//{
//protected:
//	int _num; //学号 
//	string _address; //地址
//};
//
////继承的基类成员变量(整体对象) + 自己的成员变量(遵循普通的规则，与类和对象部分一样)
////默认生成的构造，派生类自己的成员，内置类型不确定，自定义类型调用默认构造，基类部分调用默认构造
//
//int main()
//{
//	Student s;
//	return 0;
//}

//class Person
//{
//public:
//	Person(const char* name)
//		: _name(name)
//	{
//		cout << "Person()" << endl;
//	}
//
//	Person(const Person& p)
//		: _name(p._name)
//	{
//		cout << "Person(const Person& p)" << endl;
//	}
//
//	Person& operator=(const Person& p)
//	{
//		cout << "Person operator=(const Person& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//
//		return *this;
//	}
//
//	~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//protected:
//	string _name; // 姓名 
//};
//
////本质可以把派生类当作多了一个自定义类型成员变量(基类)的普通类
//class Student : public Person
//{
//public:
//	Student(const char* name = "张三", int num = 18, const char* address = "地球")
//		:Person(name)//显示调基类的构造
//		,_num(num)
//		,_address(address)
//	{ 
//		cout << "Student()" << endl;
//	}
//
//	Student(const Student& s)
//		:Person(s)//传一个派生类对象
//		,_num(s._num)
//		,_address(s._address)
//	{
//		//涉及深拷贝，需要自己实现
//	}
//
//	Student& operator=(const Student& s)
//	{
//		if (this != &s)
//		{
//			//operator=(s);//此处蕴含了一个隐藏
//			Person::operator=(s);
//			_num = s._num;
//			_address = s._address;
//		}
//		return *this;
//		//涉及深拷贝，需要自己实现
//	}
//
//	~Student()
//	{
//		//不用显示调用基类析构，编译器会在派生类析构结束后自动调用析构
//		//Person::~Person();
//		//...
//		cout << "~Student()" << endl;
//	}
//
//protected:
//	int _num; //学号 
//	string _address; //地址
//	int* _ptr;
//};
//
//// 本质可以把派生类当做多了一个自定义类型成员变量(基类)的普通类，跟普通类原则基本一样
//// 派生类一般要自己实现构造，不需要显示写析构、拷贝构造，赋值重载，除非派生类有深拷贝的资源需要处理
//
//int main()
//{
//	Student s1;
//	/*Student s2("李明", 10);
//	Student s3(s2);
//
//	s1 = s3;
//
//	Person p = s1;*/
//
//	return 0;
//}

//// C++11的⽅法 
//class Base final
//{
//public:
//	void func5() { cout << "Base::func5" << endl; }
//protected:
//	int a = 1;
//private:
//	// C++98的⽅法 
//	/*Base()
//	{}*/
//};
//
//class Derive :public Base
//{
//	void func4() { cout << "Derive::func4" << endl; }
//protected:
//	int b = 2;
//};
//
//int main()
//{
//	Base b;
//	Derive d;
//	return 0;
//}

//class Student;
//class Person
//{
//public:
//	friend void Display(const Person& p, const Student& s);
//protected:
//	string _name; // 姓名 
//};
//
//class Student : public Person
//{
//protected:
//	int _stuNum; // 学号 
//};
//
//void Display(const Person& p, const Student& s)
//{
//	cout << p._name << endl;
//	cout << s._stuNum << endl;
//}
//
//int main()
//{
//	Person p;
//	Student s;
//	// 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员 
//	// 解决⽅案：Display也变成Student 的友元即可 
//	Display(p, s);
//
//	return 0;
//}

//class Person
//{
//public:
//	string _name;
//	static int _count;
//};
//
//int Person::_count = 0;
//
//class Student : public Person
//{
//protected:
//	int _stuNum;
//};
//
//int main()
//{
//	Person p;
//	Student s;
//	// 这⾥的运⾏结果可以看到非静态成员_name的地址是不⼀样的 
//	// 说明派⽣类继承下来了，⽗派⽣类对象各有⼀份 
//	cout << &p._name << endl;
//	cout << &s._name << endl;
//	// 这⾥的运⾏结果可以看到静态成员_count的地址是⼀样的 
//	// 说明派⽣类和基类共⽤同⼀份静态成员 
//	cout << &p._count << endl;
//	cout << &s._count << endl;
//	// 公有的情况下，⽗派⽣类指定类域都可以访问静态成员 
//	cout << Person::_count << endl;
//	cout << Student::_count << endl;
//	return 0;
//}

//class Person
//{
//public:
//	Person(const char* name)
//		:_name(name)
//	{ }
//	string _name; // 姓名

//public:
//	string _name; // 姓名 
//	int _tel;
//	int _age;
//	string _address;
//};

////class Student : public Person
//class Student : virtual public Person
//{
//public:
//	Student(const char* name, int num)
//		:Person(name)
//		,_num(num)
//	{ }
//protected:
//	int _num; //学号 
//};
//
////class Teacher : public Person
//class Teacher : virtual public Person
//{
//public:
//	Teacher(const char* name, int id)
//		:Person(name)
//		,_id(id)
//	{ }
//protected:
//	int _id; // 职⼯编号 
//};
//
//class Assistant : public Student, public Teacher
//{
//public:
//	Assistant(const char* name1, const char* name2, const char* name3)
//		:Person(name1)
//		,Student(name1, 1)
//		,Teacher(name2, 2)
//	{ }
//
//protected:
//	string _majorCourse; // 主修课程 
//};
//
//int main()
//{
//	// 思考⼀下这⾥a对象中_name是"张三", "李四", "王五"中的哪⼀个？
//	Assistant a("张三", "李四", "王五");
//
//	//// 编译报错：error C2385: 对“_name”的访问不明确 
//	//Assistant a;
//	//a._name = "peter";
//	//// 需要显⽰指定访问哪个基类的成员,可以解决⼆义性问题，但是数据冗余问题⽆法解决 
//	//a.Student::_name = "xxx";
//	//a.Teacher::_name = "yyy";
//	return 0;
//}

//// 继承 is-a
//class stack : public vector
//{ };
//
//// 组合 has-a
//class stack
//{
//	vector _v;
//};

// 轮胎和车更符合has-a的关系
class Tire
{
protected:
	string _brand = "Michelin"; // 品牌
	size_t _size = 17; // 尺寸
};

class Car
{
protected:
	string _colour = "白色"; // 颜色
	string _num = "xxxxxx"; // 车牌号

	Tire _t1; // 轮胎
	Tire _t2;
	Tire _t3;
	Tire _t4;
};

// Car和BMW/Benz更符合is-a的关系 
class BMW : public Car
{
public:
	void Drive()
	{
		cout << "操控" << endl;
	}
};

class Benz : public Car
{
public:
	void Drive()
	{
		cout << "舒适" << endl;
	}
};

// stack和vector的关系，既符合is-a，也符合has-a 
template<class T>
class stack : public vector<T>
{ };

template<class T>
class stack
{
public:
	vector<T> _v;
};

int main()
{
	return 0;
}
